home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / linux / atari / source / source.lzh / atari-linux-0.01pl3 / fs / ext2 / balloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-05  |  19.8 KB  |  727 lines
  1. /*
  2.  *  linux/fs/ext2/balloc.c
  3.  *
  4.  *  Copyright (C) 1992, 1993  Remy Card (card@masi.ibp.fr)
  5.  *
  6.  *  Enhanced block allocation by Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
  7.  */
  8.  
  9. /* balloc.c contains the blocks allocation and deallocation routines */
  10.  
  11. /*
  12.  
  13.    The free blocks are managed by bitmaps.  A file system contains several
  14.    blocks groups.  Each group contains 1 bitmap block for blocks, 1 bitmap
  15.    block for inodes, N blocks for the inode table and data blocks.
  16.  
  17.    The file system contains group descriptors which are located after the
  18.    super block.  Each descriptor contains the number of the bitmap block and
  19.    the free blocks count in the block.    The descriptors are loaded in memory
  20.    when a file system is mounted (see ext2_read_super).
  21.  
  22. */
  23.  
  24. #include <linux/fs.h>
  25. #include <linux/ext2_fs.h>
  26. #include <linux/kernel.h>
  27. #include <linux/stat.h>
  28. #include <linux/sched.h>
  29. #include <linux/string.h>
  30. #include <linux/locks.h>
  31.  
  32. #include <asm/bitops.h>
  33.  
  34. #if defined(__i386__)
  35. #define clear_block(addr,size) \
  36.     __asm__("cld\n\t" \
  37.         "rep\n\t" \
  38.         "stosl" \
  39.         : \
  40.         :"a" (0), "c" (size / 4), "D" ((long) (addr)) \
  41.         :"cx", "di")
  42. #else
  43. #define clear_block(addr,size) (memset(addr,0,size))
  44. #endif
  45.  
  46. #if defined(__i386__)
  47. static inline int find_first_zero_bit (unsigned long * addr, unsigned size)
  48. {
  49.     int res;
  50.  
  51.     if (!size)
  52.         return 0;
  53.     __asm__("
  54.         cld
  55.         movl $-1,%%eax
  56.         repe; scasl
  57.         je 1f
  58.         subl $4,%%edi
  59.         movl (%%edi),%%eax
  60.         notl %%eax
  61.         bsfl %%eax,%%edx
  62.         jmp 2f
  63. 1:        xorl %%edx,%%edx
  64. 2:        subl %%ebx,%%edi
  65.         shll $3,%%edi
  66.         addl %%edi,%%edx"
  67.         :"=d" (res)
  68.         :"c" ((size + 31) >> 5), "D" (addr), "b" (addr)
  69.         :"ax", "bx", "cx", "di");
  70.     return res;
  71. }
  72.  
  73. static inline int find_next_zero_bit (unsigned long * addr, int size,
  74.                       int offset)
  75. {
  76.     unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
  77.     int set = 0, bit = offset & 31, res;
  78.  
  79.     if (bit) {
  80.         /* Look for zero in first byte */
  81.         __asm__("
  82.             bsfl %1,%0
  83.             jne 1f
  84.             movl $32, %0
  85. 1:            "
  86.             : "=r" (set)
  87.             : "r" (~(*p >> bit)));
  88.         if (set < (32 - bit))
  89.             return set + offset;
  90.         set = 32 - bit;
  91.         p++;
  92.     }
  93.     /* No zero yet, search remaining full bytes for a zero */
  94.     res = find_first_zero_bit (p, size - 32 * (p - addr));
  95.     return (offset + set + res);
  96. }
  97.  
  98. static inline char * find_first_zero_byte (char * addr, int size)
  99. {
  100.     char *res;
  101.  
  102.     if (!size)
  103.         return 0;
  104.     __asm__("
  105.         cld
  106.         mov $0,%%eax
  107.         repnz; scasb
  108.         jnz 1f
  109.         dec %%edi
  110. 1:        "
  111.         : "=D" (res)
  112.         : "0" (addr), "c" (size)
  113.         : "ax");
  114.     return res;
  115. }
  116.  
  117. #define findbit(k,lmap) __asm__ ("bsfl %1,%0"    \
  118.                                  : "=r" (k)      \
  119.                                  : "r" (~(lmap)))
  120.  
  121. #define SHIFT_DOWN(v,n) ((v) >> (n))
  122. #define SHIFT_UP(v,n) ((v) << (n))
  123.  
  124. #elif defined(__mc68000__)
  125.  
  126. static inline int find_first_zero_bit(unsigned long * addr, unsigned size)
  127. {
  128.     unsigned long res;
  129.     unsigned long *p;
  130.  
  131.     if (!size)
  132.         return 0;
  133.     __asm__ __volatile__ ("    moveq #-1,d0\n\t"
  134.                   "1:"
  135.                   "    cmpl  %1@+,d0\n\t"
  136.                   "    bne   2f\n\t"
  137.                   "    subql #1,%0\n\t"
  138.                   "    bne   1b\n\t"
  139.                   "    bra   5f\n\t"
  140.                   "2:"
  141.                   "    movel %1@-,d0\n\t"
  142.                   "    notl  d0\n\t"
  143.                   "    bfffo d0{#0,#0},%0\n\t"
  144.                   "5:"
  145.                   : "=d" (res), "=a" (p)
  146.                   : "0" ((size + 31) >> 5), "1" (addr)
  147.                   : "d0");
  148.     return ((p - addr) << 5) + res;
  149. }
  150.  
  151. static inline int find_next_zero_bit (unsigned long * addr, int size,
  152.                       int offset)
  153. {
  154.     unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
  155.     int set = 0, bit = offset & 31, res;
  156.  
  157.     if (bit) {
  158.         /* Look for zero in first longword */
  159.         __asm__("bfffo %1{#0,#0},%0"
  160.             : "=d" (set)
  161.             : "d" (~*p << bit));
  162.         if (set < (32 - bit))
  163.             return set + offset;
  164.                 set = 32 - bit;
  165.         p++;
  166.     }
  167.     /* No zero yet, search remaining full bytes for a zero */
  168.     res = find_first_zero_bit (p, size - 32 * (p - addr));
  169.     return (offset + set + res);
  170. }
  171.  
  172. static inline char * find_first_zero_byte (char * addr, int size)
  173. {
  174.     while (size--) {
  175.         if (!*addr)
  176.             break;
  177.         addr++;
  178.     }
  179.     return addr;
  180. }
  181.  
  182. #define findbit(k,lmap) __asm__ __volatile__ ("bfffo %1{#0,#0},%0" \
  183.                           : "=d" (k)       \
  184.                           : "d" (~(lmap)))
  185.  
  186. #define SHIFT_DOWN(v,n) ((v) << (n))
  187. #define SHIFT_UP(v,n) ((v) >> (n))
  188.  
  189. #endif
  190.  
  191. static void read_block_bitmap (struct super_block * sb,
  192.                    unsigned int block_group,
  193.                    unsigned long bitmap_nr)
  194. {
  195.     unsigned long group_desc;
  196.     unsigned long desc;
  197.     struct ext2_group_desc * gdp;
  198.     struct buffer_head * bh;
  199.  
  200.     group_desc = block_group / EXT2_DESC_PER_BLOCK(sb);
  201.     desc = block_group % EXT2_DESC_PER_BLOCK(sb);
  202.     if (!sb->u.ext2_sb.s_group_desc[group_desc])
  203.         ext2_panic (sb, "read_block_bitmap",
  204.                 "Group descriptor not loaded\n"
  205.                 "block_group = %d, group_desc = %lu, desc = %lu",
  206.                  block_group, group_desc, desc);
  207.     gdp = (struct ext2_group_desc *)
  208.         sb->u.ext2_sb.s_group_desc[group_desc]->b_data;
  209.     bh = bread (sb->s_dev, gdp[desc].bg_block_bitmap, sb->s_blocksize);
  210.     if (!bh)
  211.         ext2_panic (sb, "read_block_bitmap",
  212.                 "Cannot read block bitmap\n"
  213.                 "block_group = %d, group_desc = %lu,"
  214.                 "desc = %lu, block_bitmap = %lu",
  215.                 block_group, group_desc, desc,
  216.                 gdp[desc].bg_block_bitmap);
  217.     sb->u.ext2_sb.s_block_bitmap_number[bitmap_nr] = block_group;
  218.     sb->u.ext2_sb.s_block_bitmap[bitmap_nr] = bh;
  219. }
  220.  
  221. /*
  222.  * load_block_bitmap loads the block bitmap for a blocks group
  223.  *
  224.  * It maintains a cache for the last bitmaps loaded.  This cache is managed
  225.  * with a LRU algorithm.
  226.  *
  227.  * Notes:
  228.  * 1/ There is one cache per mounted file system.
  229.  * 2/ If the file system contains less than EXT2_MAX_GROUP_LOADED groups,
  230.  *    this function reads the bitmap without maintaining a LRU cache.
  231.  */
  232. static int load__block_bitmap (struct super_block * sb,
  233.                    unsigned int block_group)
  234. {
  235.     int i, j;
  236.     unsigned long block_bitmap_number;
  237.     struct buffer_head * block_bitmap;
  238.  
  239.     if (block_group >= sb->u.ext2_sb.s_groups_count)
  240.         ext2_panic (sb, "load_block_bitmap",
  241.                 "block_group >= groups_count\n"
  242.                 "block_group = %d, groups_count = %lu",
  243.                 block_group, sb->u.ext2_sb.s_groups_count);
  244.  
  245.     if (sb->u.ext2_sb.s_groups_count <= EXT2_MAX_GROUP_LOADED) {
  246.         if (sb->u.ext2_sb.s_block_bitmap[block_group]) {
  247.             if (sb->u.ext2_sb.s_block_bitmap_number[block_group] !=
  248.                 block_group)
  249.                 ext2_panic (sb, "load_block_bitmap",
  250.                         "block_group != block_bitmap_number");
  251.             else
  252.                 return block_group;
  253.         } else {
  254.             read_block_bitmap (sb, block_group, block_group);
  255.             return block_group;
  256.         }
  257.     }
  258.  
  259.     for (i = 0; i < sb->u.ext2_sb.s_loaded_block_bitmaps &&
  260.             sb->u.ext2_sb.s_block_bitmap_number[i] != block_group; i++)
  261.         ;
  262.     if (i < sb->u.ext2_sb.s_loaded_block_bitmaps &&
  263.         sb->u.ext2_sb.s_block_bitmap_number[i] == block_group) {
  264.         block_bitmap_number = sb->u.ext2_sb.s_block_bitmap_number[i];
  265.         block_bitmap = sb->u.ext2_sb.s_block_bitmap[i];
  266.         for (j = i; j > 0; j--) {
  267.             sb->u.ext2_sb.s_block_bitmap_number[j] =
  268.                 sb->u.ext2_sb.s_block_bitmap_number[j - 1];
  269.             sb->u.ext2_sb.s_block_bitmap[j] =
  270.                 sb->u.ext2_sb.s_block_bitmap[j - 1];
  271.         }
  272.         sb->u.ext2_sb.s_block_bitmap_number[0] = block_bitmap_number;
  273.         sb->u.ext2_sb.s_block_bitmap[0] = block_bitmap;
  274.     } else {
  275.         if (sb->u.ext2_sb.s_loaded_block_bitmaps <
  276.             EXT2_MAX_GROUP_LOADED)
  277.             sb->u.ext2_sb.s_loaded_block_bitmaps++;
  278.         else
  279.             brelse (sb->u.ext2_sb.s_block_bitmap
  280.                 [EXT2_MAX_GROUP_LOADED - 1]);
  281.         for (j = sb->u.ext2_sb.s_loaded_block_bitmaps - 1; j > 0;  j--) {
  282.             sb->u.ext2_sb.s_block_bitmap_number[j] =
  283.                 sb->u.ext2_sb.s_block_bitmap_number[j - 1];
  284.             sb->u.ext2_sb.s_block_bitmap[j] =
  285.                 sb->u.ext2_sb.s_block_bitmap[j - 1];
  286.         }
  287.         read_block_bitmap (sb, block_group, 0);
  288.     }
  289.     return 0;
  290. }
  291.  
  292. static inline int load_block_bitmap (struct super_block * sb,
  293.                      unsigned int block_group)
  294. {
  295.     if (sb->u.ext2_sb.s_loaded_block_bitmaps > 0 &&
  296.         sb->u.ext2_sb.s_block_bitmap_number[0] == block_group)
  297.         return 0;
  298.  
  299.     if (sb->u.ext2_sb.s_groups_count <= EXT2_MAX_GROUP_LOADED &&
  300.         sb->u.ext2_sb.s_block_bitmap_number[block_group] == block_group &&
  301.         sb->u.ext2_sb.s_block_bitmap[block_group])
  302.         return block_group;
  303.  
  304.     return load__block_bitmap (sb, block_group);
  305. }
  306.  
  307. void ext2_free_block (struct super_block * sb, unsigned long block)
  308. {
  309.     struct buffer_head * bh;
  310.     struct buffer_head * bh2;
  311.     unsigned long block_group;
  312.     unsigned long bit;
  313.     unsigned long group_desc;
  314.     unsigned long desc;
  315.     int bitmap_nr;
  316.     struct ext2_group_desc * gdp;
  317.     struct ext2_super_block * es;
  318.  
  319.     if (!sb) {
  320.         printk ("ext2_free_block: nonexistent device");
  321.         return;
  322.     }
  323.     lock_super (sb);
  324.     es = sb->u.ext2_sb.s_es;
  325.     if (block < es->s_first_data_block || block >= es->s_blocks_count) {
  326.         ext2_error (sb, "ext2_free_block", "block not in datazone");
  327.         unlock_super (sb);
  328.         return;
  329.     }
  330.  
  331.     ext2_debug ("freeing block %lu\n", block);
  332.  
  333. #if 0    /* XXX - This is incompatible with the secure rm implemented in 0.4 */
  334.     bh = get_hash_table (sb->s_dev, block, sb->s_blocksize);
  335.     if (bh)
  336.         bh->b_dirt = 0;
  337.     brelse (bh);
  338. #endif
  339.     block_group = (block - es->s_first_data_block) /
  340.               EXT2_BLOCKS_PER_GROUP(sb);
  341.     bit = (block - es->s_first_data_block) % EXT2_BLOCKS_PER_GROUP(sb);
  342.     bitmap_nr = load_block_bitmap (sb, block_group);
  343.     bh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
  344.     if (!bh)
  345.         ext2_panic (sb, "ext2_free_block",
  346.                 "Unable to load group bitmap\n"
  347.                 "block_group = %lu", block_group);
  348.     if (!clear_bit (bit, bh->b_data))
  349.         ext2_warning (sb, "ext2_free_block",
  350.                   "bit already cleared for block %lu", block);
  351.     else {
  352.         group_desc = block_group / EXT2_DESC_PER_BLOCK(sb);
  353.         desc = block_group % EXT2_DESC_PER_BLOCK(sb);
  354.         bh2 = sb->u.ext2_sb.s_group_desc[group_desc];
  355.         if (!bh2)
  356.             ext2_panic (sb, "ext2_free_block",
  357.                     "Group descriptor not loaded\n"
  358.                     "group_desc = %lu", group_desc);
  359.         gdp = (struct ext2_group_desc *) bh2->b_data;
  360.         gdp[desc].bg_free_blocks_count++;
  361.         bh2->b_dirt = 1;
  362.         es->s_free_blocks_count++;
  363.         sb->u.ext2_sb.s_sbh->b_dirt = 1;
  364.     }
  365.     bh->b_dirt = 1;
  366.     if (sb->s_flags & MS_SYNC) {
  367.         ll_rw_block (WRITE, 1, &bh);
  368.         wait_on_buffer (bh);
  369.     }
  370.     sb->s_dirt = 1;
  371.     unlock_super (sb);
  372.     return;
  373. }
  374.  
  375. /*
  376.  * ext2_new_block uses a goal block to assist allocation.  If the goal is
  377.  * free, or there is a free block within 32 blocks of the goal, that block
  378.  * is allocated.  Otherwise a forward search is made for a free block; within
  379.  * each block group the search first looks for an entire free byte in the block
  380.  * bitmap, and then for any free bit if that fails.
  381.  */
  382. int ext2_new_block (struct super_block * sb, unsigned long goal)
  383. {
  384.     struct buffer_head * bh;
  385.     char *p, *r;
  386.     int i, j, k;
  387.     unsigned long lmap;
  388.     unsigned long group_desc;
  389.     unsigned long desc;
  390.     int bitmap_nr;
  391.     struct ext2_group_desc * gdp;
  392.     struct ext2_super_block * es;
  393.  
  394. #ifdef EXT2FS_DEBUG
  395.     static int goal_hits = 0, goal_attempts = 0;
  396. #endif
  397.     if (!sb) {
  398.         printk ("ext2_new_block: nonexistent device");
  399.         return 0;
  400.     }
  401.     lock_super (sb);
  402.     es = sb->u.ext2_sb.s_es;
  403.     if (es->s_free_blocks_count <= es->s_r_blocks_count && !suser()) {
  404.         unlock_super (sb);
  405.         return 0;
  406.     }
  407.  
  408.     ext2_debug ("goal=%lu.\n", goal);
  409.  
  410. repeat:
  411.     /* First, test whether the goal block is free. */
  412.     i = ((goal - es->s_first_data_block) / EXT2_BLOCKS_PER_GROUP(sb));
  413.     group_desc = i / EXT2_DESC_PER_BLOCK(sb);
  414.     desc = i % EXT2_DESC_PER_BLOCK(sb);
  415.     gdp = (struct ext2_group_desc *)
  416.         sb->u.ext2_sb.s_group_desc[group_desc]->b_data;
  417.     if (!gdp) {
  418.         ext2_panic (sb, "ext2_new_block",
  419.                 "Descriptor not loaded for group %d", i);
  420.     }
  421.     if (gdp[desc].bg_free_blocks_count > 0) {
  422.         j = ((goal - es->s_first_data_block) %
  423.                EXT2_BLOCKS_PER_GROUP(sb));
  424. #ifdef EXT2FS_DEBUG
  425.         if (j)
  426.             goal_attempts++;
  427. #endif
  428.         bitmap_nr = load_block_bitmap (sb, i);
  429.         bh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
  430.         if (!bh) {
  431.             ext2_panic (sb, "ext2_new_block",
  432.                     "Cannot load bitmap %d", bitmap_nr);
  433.             unlock_super (sb);
  434.             return 0;
  435.         }
  436.  
  437.         ext2_debug ("goal is at %d[%lu,%lu]:%d.\n", i, group_desc,
  438.                  desc, j);
  439.         if (!test_bit(j, bh->b_data)) {
  440. #ifdef EXT2FS_DEBUG
  441.             goal_hits++;
  442.             ext2_debug ("goal bit allocated.\n");
  443. #endif
  444.             goto got_block;
  445.         }
  446.         if (j) {
  447.             /* The goal was occupied; search forward for a free
  448.                block within the next 32 blocks */
  449.             lmap = SHIFT_DOWN (((unsigned long *) bh->b_data)[j >> 5],
  450.                        (j & 31) + 1);
  451.             if (j < EXT2_BLOCKS_PER_GROUP(sb) - 32)
  452.                 lmap |= SHIFT_UP (((unsigned long *) bh->b_data)[(j >> 5) + 1],
  453.                           31 - (j & 31));
  454.             else
  455.                 lmap |= SHIFT_UP (0xffffffff, 31 - (j & 31));
  456.             if (lmap != 0xffffffffl) {
  457.                 findbit(k,lmap);
  458.                 k++;
  459.                 if ((j + k) < EXT2_BLOCKS_PER_GROUP(sb)) {
  460.                     j += k;
  461.                                         if (test_bit (j, bh->b_data)) {
  462.                                                 ext2_warning (sb, "ext2_new_block",
  463.                                                               "bit already set for block %d (search next 32)", j);
  464.                                                 for (;;)
  465.                                                         ;
  466.                                         }
  467.                     goto got_block;
  468.                 }
  469.             }
  470.         }
  471.  
  472.         ext2_debug ("Bit not found near goal\n");
  473.  
  474.         /* There has been no free block found in the near vicinity
  475.            of the goal: do a search forward through the block groups,
  476.            searching in each group first for an entire free byte in
  477.            the bitmap and then for any free bit.
  478.  
  479.            Search first in the remainder of the current group; then,
  480.            cyclicly search throught the rest of the groups. */
  481.         p = ((char *) bh->b_data) + (j >> 3);
  482.         ext2_debug ("j=%d, bh->b_data=%p\n", j, bh->b_data);
  483.         r = find_first_zero_byte (p,
  484.                       (EXT2_BLOCKS_PER_GROUP(sb) - j + 7) >> 3);
  485.         k = (r - ((char *) bh->b_data)) << 3;
  486.         if (k < EXT2_BLOCKS_PER_GROUP(sb)) {
  487.             j = k;
  488.                         if (test_bit (j, bh->b_data)) {
  489.                                 ext2_warning (sb, "ext2_new_block",
  490.                                               "bit already set for block %d (ffzerobyte)", j);
  491.                                 for (;;)
  492.                                         ;
  493.                         }
  494.             goto got_block;
  495.         }
  496.         k = find_next_zero_bit ((unsigned long *) bh->b_data,
  497.                     EXT2_BLOCKS_PER_GROUP(sb),
  498.                     j);
  499.         if (k < EXT2_BLOCKS_PER_GROUP(sb)) {
  500.             j = k;
  501.                         if (test_bit (j, bh->b_data)) {
  502.                                 ext2_warning (sb, "ext2_new_block",
  503.                                               "bit already set for block %d (fnzerobit (%lx))", j, *(unsigned long *)(&bh->b_data[j>>3]));
  504.                                 for (;;)
  505.                                         ;
  506.                         }
  507.             goto got_block;
  508.         }
  509.     }
  510.  
  511.     ext2_debug ("Bit not found in block group %d.\n", i);
  512.  
  513.     /* Now search the rest of the groups.  We assume that group_desc, desc,
  514.        i and gdp correctly point to the last group visited. */
  515.     for (k = 0; k < sb->u.ext2_sb.s_groups_count; k++) {
  516.         i++;
  517.         if (i >= sb->u.ext2_sb.s_groups_count) {
  518.             i = 0;
  519.             group_desc = 0;
  520.             desc = 0;
  521.             gdp = (struct ext2_group_desc *)
  522.                 sb->u.ext2_sb.s_group_desc[group_desc]->b_data;
  523.         }
  524.         else {
  525.             desc++;
  526.             if (desc >= EXT2_DESC_PER_BLOCK(sb)) {
  527.                 group_desc++;
  528.                 desc = 0;
  529.                 gdp = (struct ext2_group_desc *)
  530.                     sb->u.ext2_sb.s_group_desc[group_desc]
  531.                     ->b_data;
  532.             }
  533.         }
  534.         if (!gdp) {
  535.             ext2_panic (sb, "ext2_new_block",
  536.                     "Descriptor not loaded for group %d", i);
  537.         }
  538.         if (gdp[desc].bg_free_blocks_count > 0)
  539.             break;
  540.     }
  541.     if (k >= sb->u.ext2_sb.s_groups_count) {
  542.         unlock_super (sb);
  543.         return 0;
  544.     }
  545.     bitmap_nr = load_block_bitmap (sb, i);
  546.     bh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
  547.     if (!bh)
  548.         ext2_panic (sb, "ext2_new_block",
  549.                 "Unable to load bitmap for group %d", i);
  550.     r = find_first_zero_byte (bh->b_data,
  551.                   EXT2_BLOCKS_PER_GROUP(sb) >> 3);
  552.     j = (r - bh->b_data) << 3;
  553.     if (j >= EXT2_BLOCKS_PER_GROUP(sb))
  554.         j = find_first_zero_bit ((unsigned long *) bh->b_data,
  555.                      EXT2_BLOCKS_PER_GROUP(sb));
  556.     if (j >= EXT2_BLOCKS_PER_GROUP(sb)) {
  557.         ext2_error (sb, "ext2_new_block",
  558.                 "Unable to locate free bit in block group %d", i);
  559.         unlock_super (sb);
  560.         return 0;
  561.     }
  562.  
  563. got_block:
  564.  
  565.     ext2_debug ("using block group %d(%lu,%lu,%d)\n",
  566.             i, group_desc, desc, gdp[desc].bg_free_blocks_count);
  567.  
  568.     if (set_bit (j, bh->b_data)) {
  569.         ext2_warning (sb, "ext2_new_block",
  570.                   "bit already set for block %d", j);
  571.         goto repeat;
  572.     }
  573.     bh->b_dirt = 1;
  574.     if (sb->s_flags & MS_SYNC) {
  575.         ll_rw_block (WRITE, 1, &bh);
  576.         wait_on_buffer (bh);
  577.     }
  578.  
  579.     ext2_debug ("found bit %d\n", j);
  580.  
  581.     j += i * EXT2_BLOCKS_PER_GROUP(sb) + es->s_first_data_block;
  582.     if (j >= es->s_blocks_count) {
  583.         ext2_error (sb, "ext2_new_block",
  584.                 "block >= blocks count\n"
  585.                 "block_group = %d, block=%d", i, j);
  586.         unlock_super (sb);
  587.         return 0;
  588.     }
  589.     if (!(bh = getblk (sb->s_dev, j, sb->s_blocksize))) {
  590.         ext2_error (sb, "ext2_new_block", "cannot get block %d", j);
  591.         unlock_super (sb);
  592.         return 0;
  593.     }
  594.     clear_block (bh->b_data, sb->s_blocksize);
  595.     bh->b_uptodate = 1;
  596.     bh->b_dirt = 1;
  597.     brelse (bh);
  598.  
  599.     ext2_debug ("allocating block %d. "
  600.             "Goal hits %d of %d.\n", j, goal_hits, goal_attempts);
  601.  
  602.     gdp[desc].bg_free_blocks_count--;
  603.     sb->u.ext2_sb.s_group_desc[group_desc]->b_dirt = 1;
  604.     es->s_free_blocks_count--;
  605.     sb->u.ext2_sb.s_sbh->b_dirt = 1;
  606.     sb->s_dirt = 1;
  607.     unlock_super (sb);
  608.     return j;
  609. }
  610.  
  611. unsigned long ext2_count_free_blocks (struct super_block * sb)
  612. {
  613. #ifdef EXT2FS_DEBUG
  614.     struct ext2_super_block * es;
  615.     unsigned long desc_count, bitmap_count, x;
  616.     unsigned long group_desc;
  617.     unsigned long desc;
  618.     int bitmap_nr;
  619.     struct ext2_group_desc * gdp;
  620.     int i;
  621.  
  622.     lock_super (sb);
  623.     es = sb->u.ext2_sb.s_es;
  624.     desc_count = 0;
  625.     bitmap_count = 0;
  626.     group_desc = 0;
  627.     desc = 0;
  628.     gdp = NULL;
  629.     for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
  630.         if (!gdp) {
  631.             if (!sb->u.ext2_sb.s_group_desc[group_desc]) {
  632.                 printk ("ext2_count_free_block: "
  633.                     "Descriptor not loaded\n");
  634.                 break;
  635.             }
  636.             gdp = (struct ext2_group_desc *)
  637.                 sb->u.ext2_sb.s_group_desc[group_desc]->b_data;
  638.         }
  639.         desc_count += gdp[desc].bg_free_blocks_count;
  640.         bitmap_nr = load_block_bitmap (sb, i);
  641.         if (sb->u.ext2_sb.s_block_bitmap[bitmap_nr])
  642.             x = ext2_count_free
  643.                 (sb->u.ext2_sb.s_block_bitmap[bitmap_nr],
  644.                  sb->s_blocksize);
  645.         else {
  646.             x = 0;
  647.             printk ("Cannot load bitmap for group %d\n", i);
  648.         }
  649.         printk ("group %d: stored = %d, counted = %lu\n",
  650.             i, gdp[desc].bg_free_blocks_count, x);
  651.         bitmap_count += x;
  652.         desc++;
  653.         if (desc == EXT2_DESC_PER_BLOCK(sb)) {
  654.             group_desc++;
  655.             desc = 0;
  656.             gdp = NULL;
  657.         }
  658.     }
  659.     printk("ext2_count_free_blocks: stored = %lu, computed = %lu, %lu\n",
  660.            es->s_free_blocks_count, desc_count, bitmap_count);
  661.     unlock_super (sb);
  662.     return bitmap_count;
  663. #else
  664.     return sb->u.ext2_sb.s_es->s_free_blocks_count;
  665. #endif
  666. }
  667.  
  668. void ext2_check_blocks_bitmap (struct super_block * sb)
  669. {
  670.     struct ext2_super_block * es;
  671.     unsigned long desc_count, bitmap_count, x;
  672.     unsigned long group_desc;
  673.     unsigned long desc;
  674.     int bitmap_nr;
  675.     struct ext2_group_desc * gdp;
  676.     int i;
  677.  
  678.     lock_super (sb);
  679.     es = sb->u.ext2_sb.s_es;
  680.     desc_count = 0;
  681.     bitmap_count = 0;
  682.     group_desc = 0;
  683.     desc = 0;
  684.     gdp = NULL;
  685.     for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
  686.         if (!gdp) {
  687.             if (!sb->u.ext2_sb.s_group_desc[group_desc]) {
  688.                 ext2_error (sb, "ext2_check_blocks_bitmap",
  689.                         "Descriptor not loaded for group %d",
  690.                         i);
  691.                 break;
  692.             }
  693.             gdp = (struct ext2_group_desc *)
  694.                 sb->u.ext2_sb.s_group_desc[group_desc]->b_data;
  695.         }
  696.         desc_count += gdp[desc].bg_free_blocks_count;
  697.         bitmap_nr = load_block_bitmap (sb, i);
  698.         if (sb->u.ext2_sb.s_block_bitmap[bitmap_nr])
  699.             x = ext2_count_free
  700.                 (sb->u.ext2_sb.s_block_bitmap[bitmap_nr],
  701.                  sb->s_blocksize);
  702.         else {
  703.             x = 0;
  704.             ext2_error (sb, "ext2_check_blocks_bitmap",
  705.                     "Cannot load bitmap for group %d\n", i);
  706.         }
  707.         if (gdp[desc].bg_free_blocks_count != x)
  708.             ext2_error (sb, "ext2_check_blocks_bitmap",
  709.                     "Wrong free blocks count for group %d, "
  710.                     "stored = %d, counted = %lu", i,
  711.                     gdp[desc].bg_free_blocks_count, x);
  712.         bitmap_count += x;
  713.         desc++;
  714.         if (desc == EXT2_DESC_PER_BLOCK(sb)) {
  715.             group_desc++;
  716.             desc = 0;
  717.             gdp = NULL;
  718.         }
  719.     }
  720.     if (es->s_free_blocks_count != bitmap_count)
  721.         ext2_error (sb, "ext2_check_blocks_bitmap",
  722.                 "Wrong free blocks count in super block, "
  723.                 "stored = %lu, counted = %lu",
  724.                 es->s_free_blocks_count, bitmap_count);
  725.     unlock_super (sb);
  726. }
  727.